//
// Unihan Input Method
//
// Copyright © 2002-2007 Sun Wah Linux Ltd.
//
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
// USA
//
// $Id: list_ctrl.c 757 2007-05-10 08:19:31Z roger $
//


#ifdef HAVE_CONFIG_H
#	include <config.h>
#endif

#include <gnome.h>
#include <gtk/gtk.h>
#include <glib.h>
#include <glib/gprintf.h>
#include <string.h>
#include <gconf/gconf-client.h>

#include "list_ctrl.h"
#include "list_factory.h"
#include "prefedit.h"
int unihan2_no_list(char*);
static void phonetic_refresh_treeview(GtkTreeView *tv);
static void generalized_punc_refresh_treeview(GtkTreeView *tv);
static void super_sub_refresh_treeview(GtkTreeView *tv);
static void europe_currency_refresh_treeview(GtkTreeView *tv);
static void numeric_format_refresh_treeview(GtkTreeView *tv);
static void arrow_format_refresh_treeview(GtkTreeView *tv);
static void numeric_operator_refresh_treeview(GtkTreeView *tv);
static void diamonds_refresh_treeview(GtkTreeView *tv);
static void geometry_graphic_refresh_treeview(GtkTreeView *tv);
static void else_refresh_treeview(GtkTreeView *tv);
static void special_refresh_treeview(GtkTreeView *tv);

/* IM list control */
void IM_treeview_add_column(GtkTreeView *tv)
{
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkListStore *store;

	store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);

	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(_("Current IM list"),
			renderer,
			NULL);
	gtk_tree_view_append_column(tv, column);
}

//zzc
int
unihan2_no_list(char* id)
{
	       GList *l_curr = im_curr_list;
                IMInfo *info_curr;
                while (l_curr) {
                        info_curr = (IMInfo *)l_curr->data;
                        if (strcmp(id, (info_curr->id)) == 0)
                        //if(id==info_curr->id)
				break;
                        l_curr = g_list_next(l_curr);
          		}
	
	if (l_curr)return 0;
	else 	return 1;
          
}
//zzc
void
IM_refresh_treeview_by_im_list1(GtkTreeView *tv, GList *list)
{
	GtkTreeSelection *selection = gtk_tree_view_get_selection(tv);
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkListStore *store;
	GtkTreeIter iter;
	GList *l = list;
	IMInfo *info;
        int value;
	
	store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);

	while(l) {
		info = (IMInfo *)l->data;
		value=unihan2_no_list(info->id);
		if(value)
		{	gtk_list_store_append(store, &iter);
			gtk_list_store_set(store, &iter,
				STORE_1, info->cname,
				STORE_2, info->id,
				-1);
		}
		l = g_list_next(l);
	}
	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));

	column = gtk_tree_view_get_column(tv, 0);
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_clear(column);
	gtk_tree_view_column_pack_start(column, renderer, TRUE);
	gtk_tree_view_column_set_attributes(column,
			renderer,
			"text", STORE_1,
			NULL);
	if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) 
		gtk_tree_selection_select_iter(selection, &iter);
}
void
IM_refresh_treeview_by_im_list(GtkTreeView *tv, GList *list)
{
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkListStore *store;
	GtkTreeIter iter;
	GList *l = list;
	IMInfo *info;
	//int value;
	
	store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);

	while(l) {
		info = (IMInfo *)l->data;
		gtk_list_store_append(store, &iter);
		gtk_list_store_set(store, &iter,
				STORE_1, info->cname,
				STORE_2, info->id,
				-1);
		l = g_list_next(l);
	}
	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));

	column = gtk_tree_view_get_column(tv, 0);
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_clear(column);
	gtk_tree_view_column_pack_start(column, renderer, TRUE);
	gtk_tree_view_column_set_attributes(column,
			renderer,
			"text", STORE_1,
			NULL);
}

void
IM_treeview_set_selection(GtkTreeView *tv, const gchar *im_id)
{
	GtkTreeSelection *selection = gtk_tree_view_get_selection(tv);
	GtkTreeIter iter;
	GtkTreeModel *model = gtk_tree_view_get_model(tv);
	gchar *name;
	static int i;

	if(gtk_tree_model_get_iter_first(model, &iter)) {
		gtk_tree_model_get(model, &iter, 1, &name, -1);
		if(strcmp((char *)name, im_id) == 0) {
			gtk_tree_selection_select_iter(selection, &iter);
			return;
		} 
		while(gtk_tree_model_iter_next(model, &iter)) {
			gtk_tree_model_get(model, &iter, 1, &name, -1);

			if(strcmp((char*) name, im_id) == 0) {
				gtk_tree_selection_select_iter(selection, &iter);
				return;
			}
		}
		gtk_tree_model_get_iter_first(model, &iter);
		gtk_tree_selection_select_iter(selection, &iter);
	}
}

void
IM_default_create_menu_by_store(GtkComboBox *menu, GtkListStore *store)
{
        if (!store) return;

        GConfClient *client = gconf_client_get_default();
        gchar *default_im = gconf_client_get_string(client, DEFAULT_IM_KEY, NULL);
        if (!default_im) {
                default_im = "itabc";
        }

	gint default_im_idx = 0, i = 0;
	GtkTreeIter iter;
        gboolean valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
	while (valid) {
                gchar *imid;
		gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 1, &imid, -1);
                if (!strcmp(default_im, imid))
                        default_im_idx = i;
                g_free(imid);
                ++i;
                valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
	}
	gtk_combo_box_set_model(menu, GTK_TREE_MODEL(store));
        gtk_combo_box_set_active(menu, default_im_idx);

	GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
	gtk_cell_layout_clear(GTK_CELL_LAYOUT(menu));
	gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(menu), renderer, TRUE);
	gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(menu), renderer, "text", STORE_1, NULL);

	gtk_widget_set_sensitive(GTK_WIDGET(menu), TRUE);

	GtkWidget *w = glade_xml_get_widget(xml_prefedit, "defaultIMOptionLabel");
	gtk_widget_set_sensitive(w, TRUE);
	w = glade_xml_get_widget(xml_prefedit, "noIMListWarn");
	gtk_widget_hide(w);
}
#if 0
	GtkWidget *optmenu = GTK_OPTION_MENU(menu)->menu;
	GList *l = list;
	gchar *default_im = NULL;
	GtkWidget *w;

	if (!list)
		return;

	client = gconf_client_get_default();
	default_im = gconf_client_get_string(client, DEFAULT_IM_KEY, NULL);
	if (!default_im)
		default_im = "itabc";

	while (l) {
		GtkWidget *menuitem;
		info = (IMInfo *)l->data;
		
		menuitem = gtk_menu_item_new_with_label(_(info->cname));
		gtk_menu_shell_append(GTK_MENU_SHELL(optmenu), menuitem);
		gtk_widget_show(menuitem);

		if (!strcmp(default_im, info->id))
			default_im_idx = i;
		i++;
		l = g_list_next(l);
	}
	gtk_option_menu_set_history(GTK_OPTION_MENU(menu), default_im_idx);
	gtk_widget_set_sensitive(GTK_WIDGET(menu), TRUE);

	w = glade_xml_get_widget(xml_prefedit, "defaultIMOptionLabel");
	gtk_widget_set_sensitive(w, TRUE);
	w =glade_xml_get_widget(xml_prefedit, "noIMListWarn");
	gtk_widget_hide(w);
}
#endif
	
/* end IM */


/* Symbol list control */
void Symbol_treeview_add_column(GtkTreeView *tv)
{
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkListStore *store;

	store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));

	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(
			_("Symbol definition List"),
			renderer,
			NULL);
	gtk_tree_view_append_column(tv, column);
}

void
Symbol_refresh_treeview_by_symbol_list(GtkTreeView *tv, GList *list)
{
	GList *l = list;
	GtkListStore *store;
	GtkTreeIter iter;
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	gchar *label = NULL;
	gint idx = 0;

	store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
	
	while (l) {
		SymDefGroup *pSDG;
		gint modifier;
		pSDG = (SymDefGroup *)l->data;
		modifier = pSDG->modifier;
		
		if (modifier & IM_CTRL_MASK)
			label = g_strconcat("Ctrl + ", NULL);
		if (modifier & IM_SHIFT_MASK) {
			if (label)
				label = g_strconcat(label, "Shift + ", NULL);
			else
				label = g_strconcat("Shift + ", NULL);
		}
		if (modifier & IM_ALT_MASK) {
			if (label)
				label = g_strconcat(label, "Alt + ", NULL);
			else
				label = g_strconcat("Alt + ", NULL);
		}

		label = g_strdup_printf("%s%c\t=\t%s",
				label,
				'A' + pSDG->key - IM_VK_A,
				pSDG->symbol);
		gtk_list_store_append(store, &iter);
		gtk_list_store_set(store, &iter,
				STORE_1, label,
				STORE_2, idx,
				-1);
		idx++;
		l = g_list_next(l);
		free(label);
		label = NULL;
	}

	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_get_column(tv, 0);
	gtk_tree_view_column_clear(column);
	gtk_tree_view_column_pack_start(column, renderer, TRUE);
	gtk_tree_view_column_set_attributes(column,
			renderer,
			"text", STORE_1,
			NULL);
}
/* end Symbol */


/* Word list control */
void Word_treeview_add_column(GtkTreeView *tv)
{
	GtkCellRenderer *renderer;
	GtkListStore *store;
	GtkTreeViewColumn *column;

	store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));

	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(
			_("Key Definition"),
			renderer,
			NULL);
	gtk_tree_view_append_column(tv, column);

	column = gtk_tree_view_column_new_with_attributes(
			_("Word Definition"),
			renderer,
			NULL);
	gtk_tree_view_append_column(tv, column);
}

void Word_refresh_treeview_by_word_list(GtkTreeView *tv, GList *list)
{
	GtkListStore *store = NULL;
	GtkTreeIter iter;
	GtkCellRenderer *renderer = NULL;
	GtkTreeViewColumn *column = NULL;
	GList *l = list;
	
	store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);

	while (l) {
		WordDefGroup *pWDG;
		pWDG = (WordDefGroup *)l->data;
		
		gtk_list_store_append(store, &iter);
		gtk_list_store_set(store, &iter,
				STORE_1, pWDG->key,
				STORE_2, pWDG->word,
				-1);
		l = g_list_next(l);
	}

	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_get_column(tv, 0);
	gtk_tree_view_column_clear(column);
	gtk_tree_view_column_pack_start(column, renderer, TRUE);
	gtk_tree_view_column_set_attributes(column,
			renderer,
			"text", STORE_1,
			NULL);

	column = gtk_tree_view_get_column(tv, 1);
	gtk_tree_view_column_clear(column);
	gtk_tree_view_column_pack_start(column, renderer, TRUE);
	gtk_tree_view_column_set_attributes(column,
			renderer,
			"text", STORE_2,
			NULL);
}

/* Symbol Kind list control */
void
Symbol_Kind_treeview_add_column(GtkTreeView *tv)
{
	gchar *symkind[] = {
		"Phonetic",
		"Generalized Punctuation",
		/*"Superscript & Subscript",
		"Europe Currency",
		"Numeric Format",
		"Arrow",
		"Numeric Operator",
		"Diamonds",
		"Geometry Graphic",
		"Else",
		"Special"*/
			
	};
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkListStore *store;
	GtkTreeIter iter;
	gint i;

	store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);

	for(i=0; i<2; i++) {
		gtk_list_store_append(store, &iter);
		gtk_list_store_set(store, &iter,
				STORE_1, symkind[i],
				STORE_2, i,
				-1);
	}

	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));

	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(
			_("Symbol Kind List"),
			renderer,
			"text", STORE_1,
			NULL);
	gtk_tree_view_append_column(tv, column);
}
/* end Symbo Kind*/


/* Symbol Cands list control */
void
Symbol_Cands_treeview_add_column(GtkTreeView *tv)
{
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkListStore *store;
	
	store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);

	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));

	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(
			_("Symbol Cands List"),
			renderer,
			NULL);
	gtk_tree_view_append_column(tv, column);
}

void
Symbol_Cands_refresh_treeview(GtkTreeView *tv, int idx)
{
	switch (idx) {
		case 0:
			phonetic_refresh_treeview(tv);
			break;
		case 1:
			generalized_punc_refresh_treeview(tv);
			break;
		case 2:
			super_sub_refresh_treeview(tv);
			break;
		case 3:
			europe_currency_refresh_treeview(tv);
			break;
		case 4:
			numeric_format_refresh_treeview(tv);
			break;
		case 5:
			arrow_format_refresh_treeview(tv);
			break;
		case 6:
			numeric_operator_refresh_treeview(tv);
			break;
		case 7:
			diamonds_refresh_treeview(tv);
			break;
		case 8:
			geometry_graphic_refresh_treeview(tv);
			break;
		case 9:
			else_refresh_treeview(tv);
			break;
		case 10:
			special_refresh_treeview(tv);
			break;
	}
}
static void
phonetic_refresh_treeview(GtkTreeView *tv)
{
	GtkListStore *store;
	GtkTreeIter iter;
	GtkTreeViewColumn *column;
	GtkCellRenderer *renderer;
	gchar buf[6];
	gchar *label;

	buf[0] = 0xef;
	buf[1] = 0xbb;
	buf[2] = 0xbf;
	buf[3] = 0xc9;
	buf[4] = 0x99;
	buf[5] = 0;

	label = g_strdup(buf);

	store = gtk_list_store_new(1, G_TYPE_STRING);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);
	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_get_column(tv, 0);
	gtk_tree_view_column_clear(column);
	gtk_tree_view_column_pack_start(column, renderer, TRUE);
	gtk_tree_view_column_set_attributes(column,
			renderer,
			"text", STORE_1,
			NULL);
}

static void
generalized_punc_refresh_treeview(GtkTreeView *tv)
{
	GtkListStore *store;
	GtkTreeIter iter;
	GtkTreeViewColumn *column;
	GtkCellRenderer *renderer;
	gchar *label;
	gchar buf[4];

	store = gtk_list_store_new(1, G_TYPE_STRING);

	buf[0] = 0xe2;
	buf[1] = 0x80;
	buf[2] = 0x93;
	buf[3] = 0;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0x94;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0x95;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0x97;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0x98;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0x99;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0x9a;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0x9b;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0x9c;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0x9d;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0x9e;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0xa0;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0xa1;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0xa2;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0xa6;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0xb0;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0xb2;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0xb3;
	label = g_strdup(label);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0xb9;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0xba;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0xbc;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	buf[2] = 0xbe;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);

	/*buf[2] = 0x84;
	label = g_strdup(buf);
	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter,
			STORE_1, label,
			-1);*/
	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));

	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_get_column(tv, 0);
	gtk_tree_view_column_clear(column);
	gtk_tree_view_column_pack_start(column, renderer, TRUE);
	gtk_tree_view_column_set_attributes(column,
			renderer,
			"text", STORE_1,
			NULL);

}

static void
super_sub_refresh_treeview(GtkTreeView *tv)
{
	return;
}

static void
europe_currency_refresh_treeview(GtkTreeView *tv)
{
	return;
}

static void
numeric_format_refresh_treeview(GtkTreeView *tv)
{
	return;
}

static void
arrow_format_refresh_treeview(GtkTreeView *tv)
{
	return;
}

static void
numeric_operator_refresh_treeview(GtkTreeView *tv)
{
	return;
}

static void
diamonds_refresh_treeview(GtkTreeView *tv)
{
	return;
}

static void
geometry_graphic_refresh_treeview(GtkTreeView *tv)
{
	return;
}

static void
else_refresh_treeview(GtkTreeView *tv)
{
	return;
}

static void
special_refresh_treeview(GtkTreeView *tv)
{
	return;
}

/* end Symbol Cands*/



/* Key Cands treeview control */
void
Key_Cands_treeview_add_column(GtkTreeView *tv)
{
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkListStore *store;
	GtkTreeIter iter;
	int i;
	gchar *key[] = {
		"A", "B", "C", "D", "E",
		"F", "G", "H", "I", "J",
		"K", "L", "M", "N", "O",
		"P", "Q", "R", "S", "T",
		"U", "V", "W", "X", "Y",
		"Z"
	};

	store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);

	for(i=0; i<26; i++) {
		gtk_list_store_append(store, &iter);
		gtk_list_store_set(store, &iter,
				STORE_1, key[i],
				STORE_2, i,
				-1);
	}

	gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store));

	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(
			_("Key Candidates Tree View"),
			renderer,
			"text", STORE_1,
			NULL);
	gtk_tree_view_append_column(tv, column);
}
/* end Key Cands*/




/*  Symbol new list control */

/* end Symbol new*/

// vi:ts=4:nowrap:cin:expandtab
